home *** CD-ROM | disk | FTP | other *** search
/ Aminet 32 / Aminet 32 (1999)(Schatztruhe)[!][Aug 1999].iso / Aminet / game / think / MUIMineSrc.lha / MUIMineSource / ISWindow.c < prev    next >
C/C++ Source or Header  |  1999-01-03  |  12KB  |  380 lines
  1. /*
  2.         MUI Custom Window class for selecting image files for MUIMine
  3. */
  4.  
  5. #include "MFStrings.h"
  6. #include "MUIMine.h"
  7. #include "ISWindow.h"
  8.  
  9. /*
  10.     class's instance data
  11. */
  12. struct ISWindowData
  13. {
  14.     Object *    MineFieldString;    // string for mine field image file name
  15.     Object *    StartButtonString;  // string for the start button image file name
  16.     Object *    MinesDigitsString;  // string for the mines left digits image file name
  17.     Object *    TimeDigitsString;   // string for the time taken digits image file name
  18.     Object *    MineFieldPop;       // asl popup for the mine field image file
  19.     Object *    StartButtonPop;     // asl popup for the start button image file
  20.     Object *    MinesDigitsPop;     // asl popup for the mines left digits image file
  21.     Object *    TimeDigitsPop;      // asl popup for the time taken digits image file
  22.     ULONG       ExitCode;           // exit code to indicate OK or Cancel exit
  23. };
  24.  
  25.  
  26.  
  27. /*
  28.     function :    get the image file name from a string object and place
  29.                   it in the given store location
  30.  
  31.     parameters :  strobj = pointer to the string object to get the name from
  32.                   store = pointer to the location to store the result to
  33.  
  34.     return :      TRUE if the name was retrieved, FALSE otherwise
  35. */
  36. ULONG GetImageName(Object * strobj, ULONG * store)
  37. {
  38.     STRPTR pstr;
  39.     int l;
  40.  
  41.     if (GetAttr(MUIA_String_Contents, strobj, (ULONG *)&pstr))
  42.     {
  43.         l = (pstr) ? strlen(pstr) : 0;
  44.         *store = (l) ? (ULONG)pstr : NULL;
  45.         return TRUE;
  46.     }
  47.     *store = NULL;
  48.     return FALSE;
  49. }
  50.  
  51.  
  52. /*
  53.     function :    OM_NEW method handler
  54. */
  55. SAVEDS ULONG mNew(struct IClass *cl, Object *obj, struct opSet * msg)
  56. {
  57.     struct ISWindowData * data;
  58.     struct TagItem *tags,*tag;
  59.     Object * mfstring, * sbstring, * mdstring, * tdstring,
  60.            * mfpop, * sbpop, * mdpop, * tdpop, * okbutt, * cancelbutt;
  61.     STRPTR mfimage, sbimage, mdimage, tdimage,
  62.            mflabel, sblabel, mdlabel, tdlabel,
  63.            oklabel, cancellabel;
  64.  
  65.     /*
  66.         parse initial taglist
  67.     */
  68.     mfimage = sbimage = mdimage = tdimage = NULL;
  69.     for (tags = msg->ops_AttrList; tag = NextTagItem(&tags);)
  70.     {
  71.         switch (tag->ti_Tag)
  72.         {
  73.             case MUIA_ISWindow_MineFieldImage:
  74.                 mfimage = (STRPTR)tag->ti_Data;
  75.                 break;
  76.  
  77.             case MUIA_ISWindow_StartButtonImage:
  78.                 sbimage = (STRPTR)tag->ti_Data;
  79.                 break;
  80.  
  81.             case MUIA_ISWindow_MinesDigitsImage:
  82.                 mdimage = (STRPTR)tag->ti_Data;
  83.                 break;
  84.  
  85.             case MUIA_ISWindow_TimeDigitsImage:
  86.                 tdimage = (STRPTR)tag->ti_Data;
  87.                 break;
  88.         }
  89.     }
  90.  
  91.     /*
  92.         get strings
  93.     */
  94.     mflabel = GetStr(MSG_ISWINDOW_MFLABEL);
  95.     sblabel = GetStr(MSG_ISWINDOW_SBLABEL);
  96.     mdlabel = GetStr(MSG_ISWINDOW_MDLABEL);
  97.     tdlabel = GetStr(MSG_ISWINDOW_TDLABEL);
  98.     oklabel = GetStr(MSG_OKBUTT_LABEL);
  99.     cancellabel = GetStr(MSG_CANCELBUTT_LABEL);
  100.  
  101.     /*
  102.         create the window object
  103.     */
  104.     obj = (Object *)DoSuperNew(cl, obj,
  105.         MUIA_Window_Title, GetStr(MSG_ISWINDOW_TITLE),
  106.         WindowContents, VGroup,
  107.             Child, ColGroup(2),
  108.  
  109.                 Child, KeyLabel2(mflabel + 2, *mflabel),
  110.                 Child, mfpop = PopaslObject,
  111.                     MUIA_ShortHelp, GetStr(MSG_ISWINDOW_MFHELP),
  112.                     MUIA_Popstring_String, mfstring = StringObject,
  113.                         StringFrame,
  114.                         MUIA_CycleChain, 1,
  115.                         MUIA_ControlChar, *mflabel,
  116.                         MUIA_String_MaxLen, 256,
  117.                         MUIA_String_Contents, mfimage,
  118.                         MUIA_String_AdvanceOnCR, TRUE,
  119.                         End,
  120.                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  121.                     ASLFR_TitleText, GetStr(MSG_ISWINDOW_MFTITLE),
  122.                     End,
  123.  
  124.                 Child, KeyLabel2(sblabel + 2, *sblabel),
  125.                 Child, sbpop = PopaslObject,
  126.                     MUIA_ShortHelp, GetStr(MSG_ISWINDOW_SBHELP),
  127.                     MUIA_Popstring_String, sbstring = StringObject,
  128.                         StringFrame,
  129.                         MUIA_CycleChain, 1,
  130.                         MUIA_ControlChar, *sblabel,
  131.                         MUIA_String_MaxLen, 256,
  132.                         MUIA_String_Contents, sbimage,
  133.                         MUIA_String_AdvanceOnCR, TRUE,
  134.                         End,
  135.                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  136.                     ASLFR_TitleText, GetStr(MSG_ISWINDOW_SBTITLE),
  137.                     End,
  138.  
  139.                 Child, KeyLabel2(mdlabel + 2, *mdlabel),
  140.                 Child, mdpop = PopaslObject,
  141.                     MUIA_ShortHelp, GetStr(MSG_ISWINDOW_MDHELP),
  142.                     MUIA_Popstring_String, mdstring = StringObject,
  143.                         StringFrame,
  144.                         MUIA_CycleChain, 1,
  145.                         MUIA_ControlChar, *mdlabel,
  146.                         MUIA_String_MaxLen, 256,
  147.                         MUIA_String_Contents, mdimage,
  148.                         MUIA_String_AdvanceOnCR, TRUE,
  149.                         End,
  150.                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  151.                     ASLFR_TitleText, GetStr(MSG_ISWINDOW_MDTITLE),
  152.                     End,
  153.  
  154.                 Child, KeyLabel2(tdlabel + 2, *tdlabel),
  155.                 Child, tdpop = PopaslObject,
  156.                     MUIA_ShortHelp, GetStr(MSG_ISWINDOW_TDHELP),
  157.                     MUIA_Popstring_String, tdstring = StringObject,
  158.                         StringFrame,
  159.                         MUIA_CycleChain, 1,
  160.                         MUIA_ControlChar, *tdlabel,
  161.                         MUIA_String_MaxLen, 256,
  162.                         MUIA_String_Contents, tdimage,
  163.                         MUIA_String_AdvanceOnCR, TRUE,
  164.                         End,
  165.                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  166.                     ASLFR_TitleText, GetStr(MSG_ISWINDOW_TDTITLE),
  167.                     End,
  168.  
  169.                 End,  // ColGroup(2)
  170.  
  171.             Child, HGroup,
  172.                 MUIA_Group_SameSize, TRUE,
  173.                 Child, okbutt = TextObject,
  174.                     ButtonFrame,
  175.                     MUIA_CycleChain, 1,
  176.                     MUIA_ShortHelp, GetStr(MSG_ISWINDOW_OKHELP),
  177.                     MUIA_Text_Contents, oklabel + 2,
  178.                     MUIA_Text_PreParse, "\33c",
  179.                     MUIA_Text_HiChar  , *oklabel,
  180.                     MUIA_ControlChar  , *oklabel,
  181.                     MUIA_InputMode    , MUIV_InputMode_RelVerify,
  182.                     MUIA_Background   , MUII_ButtonBack,
  183.                     End,
  184.  
  185.                 Child, cancelbutt = TextObject,
  186.                     ButtonFrame,
  187.                     MUIA_CycleChain, 1,
  188.                     MUIA_ShortHelp, GetStr(MSG_ISWINDOW_CANCELHELP),
  189.                     MUIA_Text_Contents, cancellabel + 2,
  190.                     MUIA_Text_PreParse, "\33c",
  191.                     MUIA_Text_HiChar  , *cancellabel,
  192.                     MUIA_ControlChar  , *cancellabel,
  193.                     MUIA_InputMode    , MUIV_InputMode_RelVerify,
  194.                     MUIA_Background   , MUII_ButtonBack,
  195.                     End,
  196.  
  197.                 End,  // HGroup
  198.  
  199.             End,  // VGroup
  200.  
  201.         MUIA_Window_DefaultObject, okbutt,
  202.         TAG_MORE, msg->ops_AttrList);
  203.  
  204.     if (obj == NULL)
  205.     {
  206.         return 0;
  207.     }
  208.  
  209.     data = INST_DATA(cl,obj);
  210.  
  211.     /*
  212.             initialize the instance data
  213.     */
  214.     data->MineFieldString = mfstring;
  215.     data->StartButtonString = sbstring;
  216.     data->MinesDigitsString = mdstring;
  217.     data->TimeDigitsString = tdstring;
  218.  
  219.     data->MineFieldPop = mfpop;
  220.     data->StartButtonPop = sbpop;
  221.     data->MinesDigitsPop = mdpop;
  222.     data->TimeDigitsPop = tdpop;
  223.  
  224.     data->ExitCode = MUIV_ISWindow_ExitCode_Cancel;
  225.  
  226.     /*
  227.         setup notification
  228.     */
  229.     DoMethod(okbutt, MUIM_Notify, MUIA_Pressed, FALSE,
  230.                 obj, 2, MUIM_ISWindow_ExitCheck, MUIV_ISWindow_ExitCode_OK);
  231.     DoMethod(cancelbutt, MUIM_Notify, MUIA_Pressed, FALSE,
  232.                 obj, 2, MUIM_ISWindow_ExitCheck, MUIV_ISWindow_ExitCode_Cancel);
  233.     DoMethod(obj, MUIM_Notify,  MUIA_Window_CloseRequest, TRUE,
  234.                 obj, 2, MUIM_ISWindow_ExitCheck, MUIV_ISWindow_ExitCode_Cancel);
  235.  
  236.     return (ULONG)obj;
  237. }
  238.  
  239.  
  240. /*
  241.     function :    OM_DISPOSE method handler
  242. */
  243. SAVEDS ULONG mDispose(struct IClass *cl, Object *obj, Msg msg)
  244. {
  245. //        struct ISWindowData *data = INST_DATA(cl,obj);
  246.  
  247.     return DoSuperMethodA(cl,obj,msg);
  248. }
  249.  
  250.  
  251. /*
  252.     function :    OM_SET method handler
  253. */
  254. SAVEDS ULONG mSet(struct IClass *cl, Object *obj, struct opSet * msg)
  255. {
  256.     struct ISWindowData *data = INST_DATA(cl,obj);
  257.     struct TagItem *tags, *tag;
  258.  
  259.     for (tags = msg->ops_AttrList; tag = NextTagItem(&tags);)
  260.     {
  261.         switch (tag->ti_Tag)
  262.         {
  263.             case MUIA_ISWindow_ExitCode:
  264.                 data->ExitCode = tag->ti_Data;
  265.                 break;
  266.         }
  267.     }
  268.  
  269.     return DoSuperMethodA(cl, obj, (APTR)msg);
  270. }
  271.  
  272.  
  273. /*
  274.     function :    OM_GET method handler
  275. */
  276. static ULONG mGet(struct IClass *cl, Object *obj, struct opGet * msg)
  277. {
  278.     struct ISWindowData *data = INST_DATA(cl,obj);
  279.     ULONG *store = msg->opg_Storage;
  280.  
  281.     switch (msg->opg_AttrID)
  282.     {
  283.         case MUIA_ISWindow_MineFieldImage:
  284.             return GetImageName(data->MineFieldString, store);
  285.  
  286.         case MUIA_ISWindow_StartButtonImage:
  287.             return GetImageName(data->StartButtonString, store);
  288.  
  289.         case MUIA_ISWindow_MinesDigitsImage:
  290.             return GetImageName(data->MinesDigitsString, store);
  291.  
  292.         case MUIA_ISWindow_TimeDigitsImage:
  293.             return GetImageName(data->TimeDigitsString, store);
  294.  
  295.         case MUIA_ISWindow_ExitCode:
  296.             *store = data->ExitCode;
  297.             return TRUE;
  298.     }
  299.  
  300.     return DoSuperMethodA(cl, obj, (APTR)msg);
  301. }
  302.  
  303.  
  304. /*
  305.     function :    MUIM_ISWindow_ExitCheck method handler, determines if it is
  306.                   ok to close the window and sets the exit code if it can be
  307.                   else gives a message to close the requesters
  308. */
  309. static ULONG mExitCheck(struct IClass *cl, Object *obj, struct MUIP_ISWindow_ExitCheck * msg)
  310. {
  311.     struct ISWindowData *data = INST_DATA(cl,obj);
  312.     ULONG isactive;
  313.  
  314.     GetAttr(MUIA_Popasl_Active, data->MineFieldPop, &isactive);
  315.     if (!isactive) GetAttr(MUIA_Popasl_Active, data->StartButtonPop, &isactive);
  316.     if (!isactive) GetAttr(MUIA_Popasl_Active, data->MinesDigitsPop, &isactive);
  317.     if (!isactive) GetAttr(MUIA_Popasl_Active, data->TimeDigitsPop, &isactive);
  318.  
  319.     if (isactive)
  320.     {
  321.         MUI_Request(_app(obj), obj, 0, GetStr(MSG_ISWINDOW_TITLE),
  322.                                        GetStr(MSG_CONTINUE_GADGET),
  323.                                        GetStr(MSG_CLOSE_IMAGE_ASL));
  324.     }
  325.     else
  326.     {
  327.         SetAttrs(obj, MUIA_ISWindow_ExitCode, msg->ExitCode, TAG_DONE);
  328.     }
  329.  
  330.     return 0;
  331. }
  332.  
  333.  
  334. /*
  335.     function :    class dispatcher
  336. */
  337. SAVEDS ASM ULONG ISWindowDispatcher(REG(a0) struct IClass *cl,
  338.                                     REG(a2) Object *obj,
  339.                                     REG(a1) Msg msg)
  340. {
  341.     switch (msg->MethodID)
  342.     {
  343.         case OM_NEW        : return(mNew      (cl, obj, (APTR)msg));
  344.         case OM_DISPOSE    : return(mDispose  (cl, obj, (APTR)msg));
  345.         case OM_SET        : return(mSet      (cl, obj, (APTR)msg));
  346.         case OM_GET        : return(mGet      (cl, obj, (APTR)msg));
  347.  
  348.         case MUIM_ISWindow_ExitCheck:
  349.                              return mExitCheck(cl, obj, (APTR)msg);
  350.     }
  351.  
  352.     return(DoSuperMethodA(cl,obj,msg));
  353. }
  354.  
  355.  
  356.  
  357. /*
  358.     function :    creates the ISWindow MUI custom class
  359.  
  360.     return :      pointer to the created custom class or NULL
  361. */
  362. struct MUI_CustomClass * CreateISWindowClass()
  363. {
  364.     return MUI_CreateCustomClass(NULL, MUIC_Window, NULL,
  365.                                        sizeof(struct ISWindowData),
  366.                                        ISWindowDispatcher);
  367. }
  368.  
  369. /*
  370.     function :    deletes the ISWindow custom class
  371.  
  372.     parameters :  mcc = pointer to the ISWindow MUI_CustomClass to delete
  373. */
  374. void DeleteISWindowClass(struct MUI_CustomClass * mcc)
  375. {
  376.     MUI_DeleteCustomClass(mcc);
  377. }
  378.  
  379.  
  380.